<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" dir="ltr" class="client-nojs">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Namespaces - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">


<link rel="shortcut icon" href="../../../favicon.ico">



<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"cpp/language/namespace","wgTitle":"cpp/language/namespace","wgCurRevisionId":78486,"wgArticleId":5741,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":[],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"cpp/language/namespace","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:ca03345b1e2c4d90a25d968753a73b92 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-cpp {line-height: normal;}
.source-cpp li, .source-cpp pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for cpp
 * CSS class: source-cpp, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.cpp.source-cpp .de1, .cpp.source-cpp .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.cpp.source-cpp  {font-family:monospace;}
.cpp.source-cpp .imp {font-weight: bold; color: red;}
.cpp.source-cpp li, .cpp.source-cpp .li1 {font-weight: normal; vertical-align:top;}
.cpp.source-cpp .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.cpp.source-cpp .li2 {font-weight: bold; vertical-align:top;}
.cpp.source-cpp .kw1 {color: #0000dd;}
.cpp.source-cpp .kw2 {color: #0000ff;}
.cpp.source-cpp .kw3 {color: #0000dd;}
.cpp.source-cpp .kw4 {color: #0000ff;}
.cpp.source-cpp .co1 {color: #909090;}
.cpp.source-cpp .co2 {color: #339900;}
.cpp.source-cpp .coMULTI {color: #ff0000; font-style: italic;}
.cpp.source-cpp .es0 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es1 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es2 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es3 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es4 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es5 {color: #008000; font-weight: bold;}
.cpp.source-cpp .br0 {color: #008000;}
.cpp.source-cpp .sy0 {color: #008000;}
.cpp.source-cpp .sy1 {color: #000080;}
.cpp.source-cpp .sy2 {color: #000040;}
.cpp.source-cpp .sy3 {color: #000040;}
.cpp.source-cpp .sy4 {color: #008080;}
.cpp.source-cpp .st0 {color: #008000;}
.cpp.source-cpp .nu0 {color: #000080;}
.cpp.source-cpp .nu6 {color: #000080;}
.cpp.source-cpp .nu8 {color: #000080;}
.cpp.source-cpp .nu12 {color: #000080;}
.cpp.source-cpp .nu16 {color:#000080;}
.cpp.source-cpp .nu17 {color:#000080;}
.cpp.source-cpp .nu18 {color:#000080;}
.cpp.source-cpp .nu19 {color:#000080;}
.cpp.source-cpp .ln-xtra, .cpp.source-cpp li.ln-xtra, .cpp.source-cpp div.ln-xtra {background-color: #ffc;}
.cpp.source-cpp span.xtra { display:block; }

/*]]>*/
</style>
<!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]-->
</head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-cpp_language_namespace skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        
        <!-- /header -->
        <!-- content -->
        <div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
                <h1 id="firstHeading" class="firstHeading">Namespaces</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../cpp.html" title="cpp">cpp</a>‎ | <a href="../language.1.html" title="cpp/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr">
<div class="t-navbar" style="">
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head">
<a href="../../cpp.html" title="cpp"> C++</a><div class="t-navbar-menu"><div>
<div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../language.1.html" title="cpp/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="cpp/header"> Standard library headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../concept.html" title="cpp/concept"> Concepts</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html" title="cpp/utility"> Utilities library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="cpp/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../container.html" title="cpp/container"> Containers library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="cpp/algorithm"> Algorithms library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../iterator.html" title="cpp/iterator"> Iterators library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="cpp/numeric"> Numerics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="cpp/io"> Input/output library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="cpp/locale"> Localizations library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../regex.html" title="cpp/regex"> Regular expressions library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../atomic.html" title="cpp/atomic"> Atomic operations library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="cpp/thread"> Thread support library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="cpp/experimental"> Technical Specifications</a> </td></tr>
</table></div>
<div></div>
</div></div>
</div>
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head"><a href="../language.1.html" title="cpp/language"> C++ language</a></div>
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head">
<a href="declarations.html" title="cpp/language/declarations"> Declarations</a><div class="t-navbar-menu"><div>
<div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-col-table">
<td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h2"><td colspan="5"> Overview </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="cpp/language/declarations"> declaration syntax</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html#Specifiers" title="cpp/language/declarations"> decl-specifier-seq</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html#Declarators" title="cpp/language/declarations"> declarator</a> </td></tr>
<tr class="t-nv-h2"><td colspan="5"> Specifiers </td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="typedef.html" title="cpp/language/typedef"><span class="t-lines"><span>typedef</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="inline.html" title="cpp/language/inline"> inline function specifier</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="virtual.html" title="cpp/language/virtual"> virtual function specifier</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="explicit.html" title="cpp/language/explicit"> explicit function specifier</a> </td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="friend.html" title="cpp/language/friend"><span class="t-lines"><span>friend</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table">
<div><a href="constexpr.html" title="cpp/language/constexpr"><span class="t-lines"><span>constexpr</span></span></a></div>
<div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div>
</div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="storage_duration.html" title="cpp/language/storage duration"> storage class specifiers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="class.html" title="cpp/language/class"> class </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="union.html" title="cpp/language/union"> union </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="enum.html" title="cpp/language/enum"> enum </a> </td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table">
<div><a href="decltype.html" title="cpp/language/decltype"><span class="t-lines"><span>decltype</span></span></a></div>
<div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div>
</div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table">
<div><a href="auto.html" title="cpp/language/auto"><span class="t-lines"><span>auto</span></span></a></div>
<div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div>
</div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table">
<div><a href="alignas.html" title="cpp/language/alignas"><span class="t-lines"><span>alignas</span></span></a></div>
<div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div>
</div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="cv.html" title="cpp/language/cv"><span class="t-lines"><span>const/volatile</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="elaborated_type_specifier.html" title="cpp/language/elaborated type specifier"> elaborated type specifier</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="attributes.html" title="cpp/language/attributes"> attributes </a><span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv-h2"><td colspan="5"> Declarators </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reference.html" title="cpp/language/reference"> reference </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="pointer.html" title="cpp/language/pointer"> pointer </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="array.html" title="cpp/language/array"> array </a> </td></tr>
</table></div></td>
<td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h2"><td colspan="5"> Block declarations </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="cpp/language/declarations"> simple-declaration</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="type_alias.html" title="cpp/language/type alias"> alias declaration</a><span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="namespace_alias.html" title="cpp/language/namespace alias"> namespace alias definition </a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="using_declaration.html" title="cpp/language/using declaration"> using-declaration</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="namespace.html#Using-directives" title="cpp/language/namespace"> using-directive</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_assert.html" title="cpp/language/static assert"> static_assert declaration</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="asm.html" title="cpp/language/asm"> asm-definition</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="enum.html" title="cpp/language/enum"> opaque enum declaration</a><span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv-h2"><td colspan="5"> Other declarations </td></tr>
<tr class="t-nv"><td colspan="5"> <strong class="selflink"> namespace definition</strong> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function.html" title="cpp/language/function"> function declaration</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="class_template.html" title="cpp/language/class template"> class template declaration</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function_template.html" title="cpp/language/function template"> function template declaration</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="class_template.html#Explicit_instantiation" title="cpp/language/class template"> explicit template instantiation</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="template_specialization.html" title="cpp/language/template specialization"> explicit template specialization</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="language_linkage.html" title="cpp/language/language linkage"> linkage specification</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="cpp/language/declarations"> attribute declaration</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="cpp/language/declarations"> empty declaration</a> </td></tr>
</table></div></td>
</tr>
</table></div>
</div>
<div></div>
</div></div>
</div>
<div class="t-navbar-sep"> </div>
</div>
<p>Namespaces provide a method for preventing name conflicts in large projects.
</p>
<p>Symbols declared inside a namespace block are placed in a named scope that prevents them from being mistaken for identically-named symbols in other scopes.
</p>
<p>Multiple namespace blocks with the same name are allowed. All declarations within those blocks are declared in the named scope.
</p>
<table id="toc" class="toc"><tr><td>
<div id="toctitle"><h2>Contents</h2></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="namespace.html#Syntax"><span class="tocnumber">1</span> <span class="toctext">Syntax</span></a></li>
<li class="toclevel-1 tocsection-2">
<a href="namespace.html#Explanation"><span class="tocnumber">2</span> <span class="toctext">Explanation</span></a>
<ul>
<li class="toclevel-2 tocsection-3"><a href="namespace.html#Namespaces"><span class="tocnumber">2.1</span> <span class="toctext">Namespaces</span></a></li>
<li class="toclevel-2"><a href="namespace.html#Inline_namespaces"><span class="tocnumber">2.2</span> <span class="toctext">Inline namespaces</span></a></li>
<li class="toclevel-2 tocsection-5"><a href="namespace.html#Unnamed_namespaces"><span class="tocnumber">2.3</span> <span class="toctext">Unnamed namespaces</span></a></li>
<li class="toclevel-2 tocsection-6"><a href="namespace.html#Using-declarations"><span class="tocnumber">2.4</span> <span class="toctext">Using-declarations</span></a></li>
<li class="toclevel-2 tocsection-7"><a href="namespace.html#Using-directives"><span class="tocnumber">2.5</span> <span class="toctext">Using-directives</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-8"><a href="namespace.html#Notes"><span class="tocnumber">3</span> <span class="toctext">Notes</span></a></li>
<li class="toclevel-1 tocsection-9"><a href="namespace.html#Example"><span class="tocnumber">4</span> <span class="toctext">Example</span></a></li>
<li class="toclevel-1 tocsection-10"><a href="namespace.html#See_also"><span class="tocnumber">5</span> <span class="toctext">See also</span></a></li>
</ul>
</td></tr></table>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Syntax">edit</a>]</span> <span class="mw-headline" id="Syntax">Syntax</span>
</h3>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>namespace</b></code> <span class="t-spar">ns_name</span> { <span class="t-spar">declarations</span> }
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>inline</b></code> <code><b>namespace</b></code> <span class="t-spar">ns_name</span> { <span class="t-spar">declarations</span> }
</td>
<td> (2)
</td>
<td> <span class="t-mark-rev t-since-cxx11">(since C++11)</span>
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>namespace</b></code> { <span class="t-spar">declarations</span> }
</td>
<td> (3)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <span class="t-spar">ns_name</span><code><b>::</b></code><span class="t-spar">name</span>
</td>
<td> (4)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>using</b></code> <code><b>namespace</b></code> <span class="t-spar">ns_name</span><code><b>;</b></code>
</td>
<td> (5)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>using</b></code> <span class="t-spar">ns_name</span><code><b>::</b></code><span class="t-spar">name</span><code><b>;</b></code>
</td>
<td> (6)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>namespace</b></code> <span class="t-spar">name</span> <code><b>=</b></code> <span class="t-spar">qualified-namespace</span> <code><b>;</b></code>
</td>
<td> (7)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <code><b>namespace</b></code> <span class="t-spar">ns_name</span><code><b>::</b></code><span class="t-spar">name</span>
</td>
<td> (8)
</td>
<td> <span class="t-mark-rev t-since-cxx17">(since C++17)</span>
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
</table>
<div class="t-li1">
<span class="t-li">1)</span> <a href="namespace.html#Namespaces" title="cpp/language/namespace">Named namespace definition</a> for the namespace <span class="t-spar">ns_name</span>.</div>
<div class="t-li1">
<span class="t-li">2)</span> <a href="namespace.html#Inline_namespaces" title="cpp/language/namespace">Inline namespace definition</a> for the namespace <span class="t-spar">ns_name</span>. Declarations inside <span class="t-spar">ns_name</span> will be visible in its enclosing namespace.</div>
<div class="t-li1">
<span class="t-li">3)</span> <a href="namespace.html#Unnamed_namespaces" title="cpp/language/namespace">Unnamed namespace definition</a>. Its members have potential scope from their point of declaration to the end of the translation unit, and have <a href="storage_duration.html" title="cpp/language/storage duration">internal linkage</a>.</div>
<div class="t-li1">
<span class="t-li">4)</span> Namespace names (along with class names) can appear on the left hand side of the scope resolution operator, as part of <a href="lookup.html" title="cpp/language/lookup">qualified name lookup</a>.</div>
<div class="t-li1">
<span class="t-li">5)</span> <a href="namespace.html#Using-directives" title="cpp/language/namespace">using-directive</a>: From the point of view of unqualified <a href="lookup.html" title="cpp/language/lookup">name lookup</a> of any name after a using-directive and until the end of the scope in which it appears, every name from <span class="t-spar">namespace-name</span> is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive and <span class="t-spar">namespace-name</span>.</div>
<div class="t-li1">
<span class="t-li">6)</span> <a href="namespace.html#Using-declarations" title="cpp/language/namespace">using-declaration</a>: makes the symbol <span class="t-spar">name</span> from the namespace <span class="t-spar">ns_name</span> accessible for <a href="lookup.html" title="cpp/language/lookup">unqualified lookup</a> as if declared in the same namespace as where this using-declaration appears.</div>
<div class="t-li1">
<span class="t-li">7)</span> <span class="t-spar">namespace-alias-definition</span>: makes <span class="t-spar">name</span> a synonym for another namespace: see <a href="namespace_alias.html" title="cpp/language/namespace alias">namespace alias</a>
</div>
<div class="t-li1">
<span class="t-li">8)</span> nested namespace definition: <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">namespace</span> A<span class="sy4">::</span><span class="me2">B</span><span class="sy4">::</span><span class="me2">C</span> <span class="br0">{</span></span></span> is equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">namespace</span> A <span class="br0">{</span> <span class="kw1">namespace</span> B <span class="br0">{</span> <span class="kw1">namespace</span> C <span class="br0">{</span></span></span>
</div>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Explanation">edit</a>]</span> <span class="mw-headline" id="Explanation">Explanation</span>
</h3>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Namespaces">edit</a>]</span> <span class="mw-headline" id="Namespaces">Namespaces</span>
</h4>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td class="t-sdsc-nopad"> <code><b>inline</b></code><span class="t-mark">(optional)</span> <code><b>namespace</b></code> <span class="t-spar">attr</span><span class="t-mark">(optional)</span> <span class="t-spar">identifier</span> <code><b>{ </b></code> <span class="t-spar">namespace-body</span> <code><b>} </b></code>
</td>
<td class="t-sdsc-nopad">
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
</table>
<table class="t-par-begin">


<tr class="t-par">
<td>  <code>inline</code>
</td>
<td> -
</td>
<td>  if present, makes this an inline namespace (see below). Cannot appear on the <i>extension-namespace-definition</i> if the <i>original-namespace-definition</i> did not use <code>inline</code>
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">attr</span><span class="t-mark-rev t-since-cxx17">(C++17)</span>
</td>
<td> -
</td>
<td>  optional sequence of any number of <a href="attributes.html" title="cpp/language/attributes">attributes</a>
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">identifier</span>
</td>
<td> -
</td>
<td>  either a previously unused identifier, in which case this is <i>original-namespace-definition</i> or the name of a namespace, in which case this is <i>extension-namespace-definition</i> <span class="t-rev-inl t-since-cxx17"><span>or a sequence of enclosing namespace specifiers separated by ::, ending with <span class="t-spar">identifier</span>, in which case this is a <i>nested-namespace-definition</i></span> <span><span class="t-mark-rev t-since-cxx17">(since C++17)</span></span></span>
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">namespace-body</span>
</td>
<td> -
</td>
<td>  possibly empty sequence of <a href="declarations.html" title="cpp/language/declarations">declarations</a> of any kind (including class and function definitions as well as nested namespaces)
</td>
</tr>
</table>
<p>Namespace definitions are only allowed at namespace scope, including the global scope.
</p>
<p>The <span class="t-spar">namespace-body</span> defines a <a href="scope.html" title="cpp/language/scope">namespace scope</a>, which affects <a href="lookup.html" title="cpp/language/lookup">name lookup</a>.
</p>
<p>All names introduced by the declarations that appear within <span class="t-spar">namespace-body</span> (including nested namespace definitions) become members of the namespace <span class="t-spar">identifier</span>, whether this namespace definition is the original namespace definition (which introduced <span class="t-spar">identifier</span>), or an extension namespace definition (which "reopened" the already defined namespace)
</p>
<p>A namespace member that was declared within a namespace body may be defined outside of it using explicit qualification
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> Q <span class="br0">{</span>
  <span class="kw1">namespace</span> V <span class="br0">{</span> <span class="co1">// V is a member of Q, and is fully defined within Q</span>
<span class="co1">// namespace Q::V { // C++17 alternative to the above two lines</span>
    <span class="kw1">class</span> C <span class="br0">{</span> <span class="kw4">void</span> m<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="br0">}</span><span class="sy4">;</span> <span class="co1">// C is a member of V and is fully defined within V</span>
                           <span class="co1">// C::m is only declared</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// f is a member of V, but is only declared here</span>
  <span class="br0">}</span>
  <span class="kw4">void</span> V<span class="sy4">::</span><span class="me2">f</span><span class="br0">(</span><span class="br0">)</span> <span class="co1">// definition of V's member f outside of V</span>
              <span class="co1">// f's enclosing namespaces are still the global namespace, Q, and Q::V</span>
  <span class="br0">{</span>
      <span class="kw4">extern</span> <span class="kw4">void</span> h<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// This declares ::Q::V::h</span>
  <span class="br0">}</span>
  <span class="kw4">void</span> V<span class="sy4">::</span><span class="me2">C</span><span class="sy4">::</span><span class="me2">m</span><span class="br0">(</span><span class="br0">)</span> <span class="co1">// definition of V::C::m outside of the namespace (and the class body)</span>
                 <span class="co1">// enclosing namespaces are the global namespace, Q, and Q::V</span>
  <span class="br0">{</span>
  <span class="br0">}</span>
<span class="br0">}</span></pre></div></div>
<p>Out-of-namespace definitions are only allowed after the point of declaration, and only in the namespaces that enclose the original namespace (including the global namespace)<span class="t-rev-inl t-since-cxx17"><span> and they must use qualified-id syntax</span> <span><span class="t-mark-rev t-since-cxx17">(since C++17)</span></span></span>
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> Q <span class="br0">{</span>
  <span class="kw1">namespace</span> V <span class="br0">{</span> <span class="co1">// original-namespace-definition for V</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declaration of Q::V::f</span>
  <span class="br0">}</span>
  <span class="kw4">void</span> V<span class="sy4">::</span><span class="me2">f</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span> <span class="co1">// OK</span>
  <span class="kw4">void</span> V<span class="sy4">::</span><span class="me2">g</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span> <span class="co1">// Error: g() is not yet a member of V</span>
  <span class="kw1">namespace</span> V <span class="br0">{</span> <span class="co1">// extension-namespace-definition for V</span>
    <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declaration of Q::V::g</span>
  <span class="br0">}</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> R <span class="br0">{</span> <span class="co1">// not a enclosing namespace for Q</span>
   <span class="kw4">void</span> Q<span class="sy4">::</span><span class="me2">V</span><span class="sy4">::</span><span class="me2">g</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span> <span class="co1">// Error: cannot define Q::V::g inside R</span>
<span class="br0">}</span>
<span class="kw4">void</span> Q<span class="sy4">::</span><span class="me2">V</span><span class="sy4">::</span><span class="me2">g</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span> <span class="co1">// OK: global namespace encloses Q</span></pre></div></div>
<p>Names introduced by <a href="friend.html" title="cpp/language/friend">friend</a> declarations within a non-local class X become members of the innermost enclosing namespace of X, but they do not become visible to <a href="lookup.html" title="cpp/language/lookup">lookup</a> (neither unqualified nor qualified) unless a matching declaration is provided at namespace scope, either before or after the class definition. Such name may be found through <a href="adl.html" title="cpp/language/adl">ADL</a> which considers both namespaces and classes.
</p>
<p>Only the innermost enclosing namespace is considered by such friend declaration when deciding whether the name would conflict with a previously declared name.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw4">void</span> h<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
<span class="kw1">namespace</span> A <span class="br0">{</span>
  <span class="kw1">class</span> X <span class="br0">{</span>
    <span class="kw1">friend</span> <span class="kw4">void</span> f<span class="br0">(</span>X<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// A::f is a friend</span>
    <span class="kw1">class</span> Y <span class="br0">{</span>
        <span class="kw1">friend</span> <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// A::g is a friend</span>
        <span class="kw1">friend</span> <span class="kw4">void</span> h<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// A::h is a friend, no conflict with ::h</span>
    <span class="br0">}</span><span class="sy4">;</span>
  <span class="br0">}</span><span class="sy4">;</span>
  <span class="co1">// A::f, A::g and A::h are not visible at namespace scope</span>
  <span class="co1">// even though they are members of the namespace A</span>
  X x<span class="sy4">;</span>
  <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>  <span class="co1">// definition of A::g</span>
     f<span class="br0">(</span>x<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// A::X::f is found through ADL</span>
  <span class="br0">}</span>
  <span class="kw4">void</span> f<span class="br0">(</span>X<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>       <span class="co1">// definition of A::f</span>
  <span class="kw4">void</span> h<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>     <span class="co1">// definition of A::h</span>
  <span class="co1">// A::f, A::g and A::h are now visible at namespace scope</span>
  <span class="co1">// and they are also friends of A::X and A::X::Y</span>
<span class="br0">}</span></pre></div></div>
 <table class="t-rev-begin">
<tr class="t-rev t-since-cxx11">
<td>
<h4> <span class="mw-headline" id="Inline_namespaces">Inline namespaces</span>
</h4>
<p>An inline namespace is a namespace that uses the optional keyword <code>inline</code> in its <i>original-namespace-definition</i>. 
</p>
<p>Members of an inline namespace are treated as if they are members of the enclosing namespace in many situations (listed below). This property is transitive: if a namespace N contains an inline namespace M, which in turn contains an inline namespace O, then the members of O can be used as though they were members of M or N. 
</p>
<ul>
<li> A <i>using-directive</i> that names the inline namespace is implicitly inserted in the enclosing namespace (similar to the implicit using-directive for the unnamed namespace)
</li>
<li> In <a href="adl.html" title="cpp/language/adl">argument-dependent lookup</a>, when a namespace is added to the set of associated namespaces, its inline namespaces are added as well, and if an inline namespace is added to the list of associated namespaces, its enclosing namespace is added as well.
</li>
<li> Each member of an inline namespace can be partially specialized, explicitly instantiated or explicitly specialized as if it were a member of the enclosing namespace.
</li>
<li> Qualified <a href="lookup.html" title="cpp/language/lookup">name lookup</a> that examines the enclosing namespace will include the names from the inline namespaces even if the same name is present in the enclosing namespace.
</li>
</ul>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="br0">{</span> <span class="co1">// in C++14, std::literals and its member namespaces are inline</span>
   <span class="kw1">using</span> <span class="kw1">namespace</span> std<span class="sy4">::</span><span class="me2">string_literals</span><span class="sy4">;</span> <span class="co1">// makes visible operator""s </span>
                                         <span class="co1">// from std::literals::string_literals</span>
   <span class="kw4">auto</span> str <span class="sy1">=</span> <span class="st0">"abc"</span>s<span class="sy4">;</span>
<span class="br0">}</span>
<span class="br0">{</span>
   <span class="kw1">using</span> <span class="kw1">namespace</span> std<span class="sy4">::</span><span class="me2">literals</span><span class="sy4">;</span> <span class="co1">// makes visible both</span>
                                  <span class="co1">// std::literals::string_literals::operator""s</span>
                                  <span class="co1">// and std::literals::chrono_literals::operator""s</span>
   <span class="kw4">auto</span> str <span class="sy1">=</span> <span class="st0">"abc"</span>s<span class="sy4">;</span>
   <span class="kw4">auto</span> min <span class="sy1">=</span> 60s<span class="sy4">;</span>
<span class="br0">}</span>
<span class="br0">{</span>
   <span class="kw1">using</span> std<span class="sy4">::</span><span class="me2">operator</span><span class="st0">""</span>s<span class="sy4">;</span> <span class="co1">// makes both std::literals::string_literals::operator""s</span>
                           <span class="co1">// and std::literals::chrono_literals::operator""s visible</span>
   <span class="kw4">auto</span> str <span class="sy1">=</span> <span class="st0">"abc"</span>s<span class="sy4">;</span>
   <span class="kw4">auto</span> min <span class="sy1">=</span> 60s<span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Note: the rule about specializations allows library versioning: different implementations of a library template may be defined in different inline namespaces, while still allowing the user to extend the parent namespace with an explicit specialization of the primary template.
</p>
</td>
<td><span class="t-mark-rev t-since-cxx11">(since C++11)</span></td>
</tr>
</table>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Unnamed namespaces">edit</a>]</span> <span class="mw-headline" id="Unnamed_namespaces">Unnamed namespaces</span>
</h4>
<p>The <i>unnamed-namespace-definition</i> is a namespace definition of the form
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td class="t-sdsc-nopad"> <code><b>inline</b></code><span class="t-mark">(optional)</span> <code><b>namespace</b></code> <span class="t-spar">attr</span><span class="t-mark">(optional)</span> <code><b>{ </b></code> <span class="t-spar">namespace-body</span> <code><b>} </b></code>
</td>
<td class="t-sdsc-nopad">
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
</table>
<table class="t-par-begin">


<tr class="t-par">
<td>  <span class="t-spar">attr</span><span class="t-mark-rev t-since-cxx17">(C++17)</span>
</td>
<td> -
</td>
<td>  optional sequence of any number of <a href="attributes.html" title="cpp/language/attributes">attributes</a>
</td>
</tr>
</table>
<p>This definition is treated as a definition of a namespace with unique name and a <i>using-directive</i> in the current scope that nominates this unnamed namespace.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>  <span class="co1">// defines ::(unique)::i</span>
<span class="br0">}</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    i<span class="sy2">++</span><span class="sy4">;</span>  <span class="co1">// increments ::(unique)::i</span>
<span class="br0">}</span>
 
<span class="kw1">namespace</span> A <span class="br0">{</span>
    <span class="kw1">namespace</span> <span class="br0">{</span>
        <span class="kw4">int</span> i<span class="sy4">;</span> <span class="co1">// A::(unique)::i</span>
        <span class="kw4">int</span> j<span class="sy4">;</span> <span class="co1">// A::(unique)::j</span>
    <span class="br0">}</span>
    <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> i<span class="sy2">++</span><span class="sy4">;</span> <span class="br0">}</span> <span class="co1">// A::unique::i++</span>
<span class="br0">}</span>
 
<span class="kw1">using</span> <span class="kw1">namespace</span> A<span class="sy4">;</span> <span class="co1">// introduces all names from A into global namespace</span>
<span class="kw4">void</span> h<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    i<span class="sy2">++</span><span class="sy4">;</span>    <span class="co1">// error: ::(unique)::i and ::A::(unique)::i are both in scope</span>
    A<span class="sy4">::</span><span class="me2">i</span><span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// ok, increments ::A::(unique)::i</span>
    j<span class="sy2">++</span><span class="sy4">;</span>    <span class="co1">// ok, increments ::A::(unique)::j</span>
<span class="br0">}</span></pre></div></div>
 <table class="t-rev-begin">
<tr class="t-rev t-until-cxx11">
<td>
<p>Even though names in an unnamed namespace may be declared with external linkage, they are never accessible from other translation units because their namespace name is unique.
</p>
</td>
<td><span class="t-mark-rev t-until-cxx11">(until C++11)</span></td>
</tr>
<tr class="t-rev t-since-cxx11">
<td>
<p>Unnamed namespaces as well as all namespaces declared directly or indirectly within an unnamed namespace have <a href="storage_duration.html#Linkage" title="cpp/language/storage duration">internal linkage</a>, which means that any name that is declared within an unnamed namespace has internal linkage.
</p>
</td>
<td><span class="t-mark-rev t-since-cxx11">(since C++11)</span></td>
</tr>
</table>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Using-declarations">edit</a>]</span> <span class="mw-headline" id="Using-declarations">Using-declarations</span>
</h4>
<p>Introduces a name that is defined elsewhere into the declarative region where this using-declaration appears.
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td class="t-sdsc-nopad"> <code><b>using</b></code> <code><b>typename</b></code><span class="t-mark">(optional)</span> <span class="t-spar">nested-name-specifier</span> <span class="t-spar">unqualified-id</span> <code><b>;</b></code>
</td>
<td class="t-sdsc-nopad">
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
</table>
<table class="t-par-begin">


<tr class="t-par">
<td>  <span class="t-spar">nested-name-specifier</span>
</td>
<td> -
</td>
<td>  a sequence of names and scope resolution operators <code>::</code>, ending with a scope resolution operator. A single <code>::</code> refers to the global namespace.
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">unqualified-id</span>
</td>
<td> -
</td>
<td>  an <a href="name.html" title="cpp/language/identifiers">id-expression</a>
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">typename</span>
</td>
<td> -
</td>
<td>  the keyword <code>typename</code> may be used as necessary to resolve <a href="dependent_name.html" title="cpp/language/dependent name">dependent names</a>, when the using-declaration introduces a member type from a base class into a class template
</td>
</tr>
</table>
<p>Using-declarations can be used to introduce namespace members into other namespaces and block scopes, or to introduce base class members into derived class definitions.
</p>
<p>For the use in derived class definitions, see <a href="using_declaration.html" title="cpp/language/using declaration">using declaration</a>.
</p>
<p>Names introduced into a namespace scope by a using-declaration can be used just like any other names, including qualified lookup from other scopes:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
<span class="kw1">namespace</span> A <span class="br0">{</span>
    <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> X <span class="br0">{</span>
    <span class="kw1">using</span> <span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// global f is now visible as ::X::f</span>
    <span class="kw1">using</span> A<span class="sy4">::</span><span class="me2">g</span><span class="sy4">;</span> <span class="co1">// A::g is now visilbe as ::X::g</span>
<span class="br0">}</span>
<span class="kw4">void</span> h<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    X<span class="sy4">::</span><span class="me2">f</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// calls ::f</span>
    X<span class="sy4">::</span><span class="me2">g</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// calls A::g</span>
<span class="br0">}</span></pre></div></div>
<p>If, after the using-declaration was used to take a member from a namespace, the namespace is extended and additional declarations for the same name are introduced, those additional declarations do not become visible through the using-declaration (in contrast with using-directive). One exception is when a using-declaration names a class template: partial specializations introduced later are effectively visible, because their <a href="lookup.html" title="cpp/language/lookup">lookup</a> proceeds through the primary template.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> A <span class="br0">{</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">using</span> A<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// ::f is now a synonym for A::f(int)</span>
 
<span class="kw1">namespace</span> A <span class="br0">{</span> <span class="co1">// namespace extension</span>
   <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">char</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// does not change what ::f means</span>
<span class="br0">}</span>
<span class="kw4">void</span> foo<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    f<span class="br0">(</span><span class="st0">'a'</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// calls f(int), even though f(char) exists.</span>
<span class="br0">}</span> 
<span class="kw4">void</span> bar<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
   <span class="kw1">using</span> A<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// this f is a synonym for both A::f(int) and A::f(char)</span>
   f<span class="br0">(</span><span class="st0">'a'</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// calls f(char)</span>
<span class="br0">}</span></pre></div></div>
<p>Using-declarations cannot name template-id, namespace, or a scoped enumerator. Each using-declaration introduces one and only one name, for example using-declaration for an <a href="enum.html" title="cpp/language/enum">enumeration</a> does not introduce any of its enumerators.
</p>
<p>All restrictions on regular declarations of the same names, hiding, and overloading rules apply to using-declarations:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> A <span class="br0">{</span>
    <span class="kw4">int</span> x<span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> B <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>
    <span class="kw1">struct</span> g <span class="br0">{</span> <span class="br0">}</span><span class="sy4">;</span>
    <span class="kw1">struct</span> x <span class="br0">{</span> <span class="br0">}</span><span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">double</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw4">void</span> g<span class="br0">(</span><span class="kw4">char</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK: function name g hides struct g</span>
<span class="br0">}</span>
<span class="kw4">void</span> func<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>
    <span class="kw1">using</span> B<span class="sy4">::</span><span class="me2">i</span><span class="sy4">;</span> <span class="co1">// error: i declared twice</span>
 
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">char</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw1">using</span> B<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// OK: f(char), f(int), f(double) are overloads</span>
    f<span class="br0">(</span><span class="nu16">3.5</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// calls B::f(double)</span>
 
    <span class="kw1">using</span> B<span class="sy4">::</span><span class="me2">g</span><span class="sy4">;</span>
    g<span class="br0">(</span><span class="st0">'a'</span><span class="br0">)</span><span class="sy4">;</span>      <span class="co1">// calls B::g(char)</span>
    <span class="kw1">struct</span> g g1<span class="sy4">;</span> <span class="co1">// declares g1 to have type struct B::g</span>
 
    <span class="kw1">using</span> B<span class="sy4">::</span><span class="me2">x</span><span class="sy4">;</span>
    <span class="kw1">using</span> A<span class="sy4">::</span><span class="me2">x</span><span class="sy4">;</span>  <span class="co1">// OK: hides struct B::x</span>
    x <span class="sy1">=</span> <span class="nu0">99</span><span class="sy4">;</span>      <span class="co1">// assigns to A::x</span>
    <span class="kw1">struct</span> x x1<span class="sy4">;</span> <span class="co1">// declares x1 to have type struct B::x</span>
<span class="br0">}</span></pre></div></div>
<p>If a function was introduced by a using-declaration, declaring a function with the same name and parameter list is ill-formed (unless the declaration is for the same function). If a function template was introduced by a using-declaration, declaring a function template with the same name, parameter type list, return type, and template parameter list is ill-formed.
Two using-declarations can introduce functions with the same name and parameter list, but if a call to that function is attempted, the program is ill-formed. 
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> B <span class="br0">{</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">double</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> C <span class="br0">{</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">double</span><span class="br0">)</span><span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">char</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw4">void</span> h<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    <span class="kw1">using</span> B<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// introduces B::f(int), B::f(double)</span>
    <span class="kw1">using</span> C<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// introduces C::f(int), C::f(double), and C::f(char)</span>
    f<span class="br0">(</span><span class="st0">'h'</span><span class="br0">)</span><span class="sy4">;</span>      <span class="co1">// calls C::f(char)</span>
    f<span class="br0">(</span><span class="nu0">1</span><span class="br0">)</span><span class="sy4">;</span>        <span class="co1">// error: B::f(int) or C::f(int)?</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// error: f(int) conflicts with C::f(int) and B::f(int)</span>
<span class="br0">}</span></pre></div></div>
 <table class="t-rev-begin">
<tr class="t-rev t-since-cxx17">
<td>
<p>If an entity is declared, but not defined in some inner namespace, and then declared through using-declaration in the outer namespace, and then a definition appears in the outer namespace with the same unqualified name, that definition is a member of the outer namespace and conflicts with the using-declration:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> X <span class="br0">{</span>
  <span class="kw1">namespace</span> M <span class="br0">{</span>
     <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declares, but doesn't define X::M::g()</span>
  <span class="br0">}</span>
  <span class="kw1">using</span> M<span class="sy4">::</span><span class="me2">g</span><span class="sy4">;</span>
  <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>   <span class="co1">// Error: attempt to declare X::g which conflicts with X::M::g()</span>
<span class="br0">}</span></pre></div></div>
<p>More generally, a declaration that appears in any namespace scope and introduces a name using an unqualified identifier always introduces a member into the namespace it's in and not to any other namespace. The exceptions are explicit instantiations and explicit specializations of a primary template that is defined in an inline namespace: because they do not introduce a new name, they may use unqualified-id in an enclosing namespace.
</p>
</td>
<td><span class="t-mark-rev t-since-cxx17">(since C++17)</span></td>
</tr>
</table>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Using-directives">edit</a>]</span> <span class="mw-headline" id="Using-directives">Using-directives</span>
</h4>
<p>A <i>using-directive</i> is a <a href="declarations.html" title="cpp/language/declarations">block-declaration</a> with the following syntax:
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
<tr class="t-sdsc">
<td> <span class="t-spar">attr</span><span class="t-mark">(optional)</span> <code><b>using</b></code> <code><b>namespace</b></code> <span class="t-spar">nested-name-specifier</span><span class="t-mark">(optional)</span> <span class="t-spar">namespace-name</span> <code><b>;</b></code>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td>
</tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td>
</tr>
</table>
<table class="t-par-begin">


<tr class="t-par">
<td>  <span class="t-spar">attr</span><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td>
<td> -
</td>
<td>  any number of <a href="attributes.html" title="cpp/language/attributes">attributes</a> that apply to this using-directive
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">nested-name-specifier</span>
</td>
<td> -
</td>
<td>  a sequence of names and scope resolution operators <code>::</code>, ending with a scope resolution operator. A single <code>::</code> refers to the global namespace.
</td>
</tr>
<tr class="t-par">
<td>  <span class="t-spar">namespace-name</span>
</td>
<td> -
</td>
<td>  a name of a namespace. When looking up this name, <a href="lookup.html" title="cpp/language/lookup">lookup</a> considers namespace declarations only
</td>
</tr>
</table>
<p>Using-directives are allowed only in namespace <a href="scope.html" title="cpp/language/scope">scope</a> and in block scope. From the point of view of unqualified <a href="lookup.html" title="cpp/language/lookup">name lookup</a> of any name after a using-directive and until the end of the scope in which it appears, every name from <span class="t-spar">namespace-name</span> is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive and <span class="t-spar">namespace-name</span>.
</p>
<p>Using-directive does not add any names to the declarative region in which it appears (unlike the using-declaration), and thus does not prevent identical names from being declared.
</p>
<p>Using-directives are transitive for the purposes of <a href="lookup.html" title="cpp/language/lookup">unqualified lookup</a>: if a scope contains a using-directive that nominates a <span class="t-spar">namespace-name</span>, which itself contains using-directive for some <span class="t-spar">namespace-name-2</span>, the effect is as if the using directives from the second namespace appear within the first. The order in which these transitive namespaces occur does not influence name lookup.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> A <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> B <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>
    <span class="kw4">int</span> j<span class="sy4">;</span>
    <span class="kw1">namespace</span> C <span class="br0">{</span>
        <span class="kw1">namespace</span> D <span class="br0">{</span>
            <span class="kw1">using</span> <span class="kw1">namespace</span> A<span class="sy4">;</span> <span class="co1">// all names from A injected into global namespace</span>
            <span class="kw4">int</span> j<span class="sy4">;</span>
            <span class="kw4">int</span> k<span class="sy4">;</span>
            <span class="kw4">int</span> a <span class="sy1">=</span> i<span class="sy4">;</span> <span class="co1">// i is B::i, because A::i is hidden by B::i</span>
        <span class="br0">}</span>
        <span class="kw1">using</span> <span class="kw1">namespace</span> D<span class="sy4">;</span> <span class="co1">// names from D are injected into C</span>
                           <span class="co1">// names from A are injected into global namespace</span>
        <span class="kw4">int</span> k <span class="sy1">=</span> <span class="nu0">89</span><span class="sy4">;</span> <span class="co1">// OK to declare name identical to one introduced by a using</span>
        <span class="kw4">int</span> l <span class="sy1">=</span> k<span class="sy4">;</span>  <span class="co1">// ambiguous: C::k or D::k</span>
        <span class="kw4">int</span> m <span class="sy1">=</span> i<span class="sy4">;</span>  <span class="co1">// ok: B::i hides A::i</span>
        <span class="kw4">int</span> n <span class="sy1">=</span> j<span class="sy4">;</span>  <span class="co1">// ok: D::j hides B::j</span>
    <span class="br0">}</span>
<span class="br0">}</span></pre></div></div>
<p>If, after a using-directive was used to nominate some namespace, the namespace is extended an additional members and/or using-directives are added to it, those additional members and the additional namespaces are visible through the using-directive (in contrast with using-declaration)
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw1">namespace</span> D <span class="br0">{</span>
   <span class="kw4">int</span> d1<span class="sy4">;</span>
   <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">char</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">using</span> <span class="kw1">namespace</span> D<span class="sy4">;</span> <span class="co1">// introduces D::d1, D::f, D::d2, D::f,</span>
                   <span class="co1">//  E::e, and E::f into global namespace!</span>
 
<span class="kw4">int</span> d1<span class="sy4">;</span> <span class="co1">// OK: no conflict with D::d1 when declaring</span>
<span class="kw1">namespace</span> E <span class="br0">{</span>
    <span class="kw4">int</span> e<span class="sy4">;</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw1">namespace</span> D <span class="br0">{</span> <span class="co1">// namespace extension</span>
    <span class="kw4">int</span> d2<span class="sy4">;</span>
    <span class="kw1">using</span> <span class="kw1">namespace</span> E<span class="sy4">;</span> <span class="co1">// transitive using-directive</span>
    <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
    d1<span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// error: ambiguous ::d1 or D::d1?</span>
    <span class="sy4">::</span><span class="me2">d1</span><span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// OK</span>
    D<span class="sy4">::</span><span class="me2">d1</span><span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// OK</span>
    d2<span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// OK, d2 is D::d2</span>
    e<span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// OK: e is E::e due to transitive using</span>
    f<span class="br0">(</span><span class="nu0">1</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// error: ambiguous: D::f(int) or E::f(int)?</span>
    f<span class="br0">(</span><span class="st0">'a'</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK: the only f(char) is D::f(char)</span>
<span class="br0">}</span></pre></div></div>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Notes">edit</a>]</span> <span class="mw-headline" id="Notes">Notes</span>
</h3>
<p>The using-directive <code>using namespace std;</code> at any namespace scope introduces every name from the namespace <code>std</code> into the global namespace (since the global namespace is the nearest namespace that contains both <code>std</code> and any user-declared namespace), which may lead to undesirable name collisions. This, and other using directives are generally considered bad practice at file scope of a header file.
</p>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Example">edit</a>]</span> <span class="mw-headline" id="Example">Example</span>
</h3>
<div class="t-example">
<p> This example shows how to use a namespace to create a class that already has been named in the <code>std</code> namespace. 
 </p>
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;vector&gt;</span>
 
<span class="kw1">namespace</span> vec <span class="br0">{</span>
 
    <span class="kw1">template</span><span class="sy1">&lt;</span> <span class="kw1">typename</span> T <span class="sy1">&gt;</span>
    <span class="kw1">class</span> vector <span class="br0">{</span>
        <span class="co1">// ...</span>
    <span class="br0">}</span><span class="sy4">;</span>
 
<span class="br0">}</span> <span class="co1">// of vec</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <a href="../container/vector.html"><span class="kw1065">std::<span class="me2">vector</span></span></a><span class="sy1">&lt;</span><span class="kw4">int</span><span class="sy1">&gt;</span> v1<span class="sy4">;</span> <span class="co1">// Standard vector.</span>
    vec<span class="sy4">::</span><span class="me2">vector</span><span class="sy1">&lt;</span><span class="kw4">int</span><span class="sy1">&gt;</span> v2<span class="sy4">;</span> <span class="co1">// User defined vector.</span>
 
    v1 <span class="sy1">=</span> v2<span class="sy4">;</span> <span class="co1">// Error: v1 and v2 are different object's type.</span>
 
    <span class="br0">{</span>
        <span class="kw1">using</span> <span class="kw1">namespace</span> std<span class="sy4">;</span>
        vector<span class="sy1">&lt;</span><span class="kw4">int</span><span class="sy1">&gt;</span> v3<span class="sy4">;</span> <span class="co1">// Same as std::vector</span>
        v1 <span class="sy1">=</span> v3<span class="sy4">;</span> <span class="co1">// OK</span>
    <span class="br0">}</span>
 
    <span class="br0">{</span>
        <span class="kw1">using</span> vec<span class="sy4">::</span><span class="me2">vector</span><span class="sy4">;</span>
        vector<span class="sy1">&lt;</span><span class="kw4">int</span><span class="sy1">&gt;</span> v4<span class="sy4">;</span> <span class="co1">// Same as vec::vector</span>
        v2 <span class="sy1">=</span> v4<span class="sy4">;</span> <span class="co1">// OK</span>
    <span class="br0">}</span>
 
    <span class="kw1">return</span> <span class="nu0">0</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p><br> 
</p>
</div>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: See also">edit</a>]</span> <span class="mw-headline" id="See_also">See also</span>
</h3>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <a href="namespace_alias.html" title="cpp/language/namespace alias"> namespace alias </a>
</td>
<td>  creates an alias of an existing namespace
</td>
</tr>
</table>

<!-- 
NewPP limit report
Preprocessor visited node count: 3497/1000000
Preprocessor generated node count: 8480/1000000
Post‐expand include size: 78966/2097152 bytes
Template argument size: 26769/2097152 bytes
Highest expansion depth: 15/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:5741-0!*!0!!en!*!* and timestamp 20150524020019 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="http%3A//en.cppreference.com/mwiki/index.php">http://en.cppreference.com/mwiki/index.php?title=cpp/language/namespace&amp;oldid=78486</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <div id="catlinks" class="catlinks catlinks-allhidden"></div>                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>

<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 0.081 secs. -->
	</body>
<!-- Cached 20150524022417 -->
</html>
